#ifndef MY_THREAD_H
#define MY_THREAD_H

#include <thread>
#include <atomic>
#include <memory>
#include <string>
#include <functional>
#include <mutex>
#include <condition_variable>

namespace T_THREAD
{
    class Thread {
    public:
        // 定义线程的几种状态
        enum class State {
            Ready,   // 准备就绪（尚未启动）
            Running, // 正在运行
            Stopped  // 已停止
        };

        // 构造函数
        Thread();
        // 析构函数，会自动join线程
        ~Thread();

        // 禁止拷贝，但允许移动
        Thread(const Thread&) = delete;
        Thread& operator=(const Thread&) = delete;
        Thread(Thread&& other) noexcept;
        Thread& operator=(Thread&& other) noexcept;

        /**
         * @brief 启动线程
         * @param function 线程要执行的函数
         * @param name 线程名称
         * @return 如果启动成功返回true，如果线程已在运行则返回false
         */
        bool start(const std::string& name, std::function<void()> function);

        /**
         * @brief 请求停止线程（非阻塞）
         * 这是一个协作式的停止请求。线程函数需要定期检查 is_stop_requested()
         */
        void request_stop();

        /**
         * @brief 等待线程执行结束（阻塞）
         */
        void join();

        /**
         * @brief 获取当前线程状态
         */
        State get_state() const;

        /**
         * @brief 检查是否已请求停止
         * @return 如果已调用 request_stop() 则返回true
         */
        bool is_stop_requested() const;

        /**
         * @brief 获取线程ID
         */
        std::thread::id get_id() const;

        std::mutex& get_mutex();
        std::condition_variable& get_cv();

    private:
        std::unique_ptr<std::thread>    thread_;
        std::atomic<State>              state_;
        std::atomic<bool>               stop_requested_;
        std::mutex                      mutex_;
        std::condition_variable         cv_;

        static void set_current_thread_name(const std::string& name);
        void thread_entry(const std::string& name, std::function<void()>& function);
    };
} // namespace MY_THREAD

using THREAD = T_THREAD::Thread;

#endif // MY_THREAD_H